Loading libraries

rm(list=ls(all=TRUE)) 

library(devtools)
#suppressMessages(devtools::install_github("r-spatial/sf"))
library(sf)
#suppressMessages(devtools::install_github("ropensci/osmdata"))
suppressMessages(library(osmdata))
suppressMessages(library(raster))
#suppressMessages(devtools::install_github("tidyverse/ggplot2"))
library(ggplot2)
library(rgeos)
library(maptools)
library(rgdal)
library(rgeos)
library(data.table)
library(knitr)
suppressMessages(library(mapview))
library(RCurl)
library(stplanr)

Import building height data

Building height data is downloaded from Copernicus Urban Atlas, unzipped and extracted.

The methodology for their creation, by [gaf.d])(https://www.gaf.de/), was as following: “Our original input data were Cartosat-1 acquisitions. The following processing system uses a customised and specialised semi-global matching algorithm to generate am 3m in close cooperation with DLR (German Aerospace Center). Subsequent to the highly automated DSM generation, a DTM was calculated and a nDSM (normalised Digital Surface Model) derived by using internal software and processing tools. The nDSM were finally resampled from 3m up to 10m resolution by using the maximum height value”.

This raster is then imported.

london_raster <- raster('buildings_raster/UK001L2_LONDON_UA2012_DHM/UK001L2_LONDON_UA2012_DHM.tif')
plot(london_raster)
title('Raster file of London Building heights')

plot(london_raster, xlim = c(3615000, 3625000), ylim = c(3200000, 3205000))
title('Raster file of London Building heights (zoomed)')

Import OSM roads data

First we get the extent of the raster

extent              <- extent(london_raster)
extent              <- as(extent, 'SpatialPolygons')
proj4string(extent) <- crs(london_raster)
latlong             <- CRS("+init=epsg:4326")
extent              <- spTransform(extent, latlong)

min_x   <- extent(extent)[1]
max_x   <- extent(extent)[2]
min_y   <- extent(extent)[3]
max_y   <- extent(extent)[4]
rm(extent)

Now using the osmdata package we can download osmdata for the extent we just defined. Roads have the value ‘highway’ in OpenStreetMap. Within that heading, we can also filter using the following tags:

available_tags('highway')
##  [1] "bridleway"              "bus guideway"          
##  [3] "bus stop"               "construction"          
##  [5] "crossing"               "cycleway"              
##  [7] "elevator"               "emergency access point"
##  [9] "escape"                 "footway"               
## [11] "give way"               "living street"         
## [13] "mini roundabout"        "motorway"              
## [15] "motorway junction"      "motorway link"         
## [17] "passing place"          "path"                  
## [19] "pedestrian"             "primary"               
## [21] "primary link"           "proposed"              
## [23] "raceway"                "residential"           
## [25] "rest area"              "road"                  
## [27] "secondary"              "secondary link"        
## [29] "service"                "services"              
## [31] "speed camera"           "steps"                 
## [33] "stop"                   "street lamp"           
## [35] "tertiary"               "tertiary link"         
## [37] "track"                  "traffic signals"       
## [39] "trunk"                  "trunk link"            
## [41] "turning circle"         "unclassified"

Now we import OSM roads data for the following road types.

primary           <- opq(bbox = c(min_x, min_y, max_x, max_y)) %>% add_osm_feature(key = 'highway', value='primary') %>% osmdata_sf()
primary           <- primary$osm_lines[,c('osm_id', 'oneway', 'lanes', 'geometry')]
primary$type      <- 'primary'

secondary         <- opq(bbox = c(min_x, min_y, max_x, max_y)) %>% add_osm_feature(key = 'highway', value='secondary') %>% osmdata_sf()
secondary         <- secondary$osm_lines[,c('osm_id', 'oneway', 'lanes', 'geometry')]
secondary$type    <- 'secondary'

motorway          <- opq(bbox = c(min_x, min_y, max_x, max_y)) %>% add_osm_feature(key = 'highway', value='motorway') %>% osmdata_sf()
motorway          <- motorway$osm_lines[,c('osm_id', 'oneway', 'lanes', 'geometry')]
motorway$type     <- 'motorway'

trunk             <- opq(bbox = c(min_x, min_y, max_x, max_y)) %>% add_osm_feature(key = 'highway', value='trunk') %>% osmdata_sf()
trunk             <- trunk$osm_lines[,c('osm_id', 'oneway', 'lanes', 'geometry')]
trunk$type        <- 'trunk'

tertiary          <- opq(bbox = c(min_x, min_y, max_x, max_y)) %>% add_osm_feature(key = 'highway', value='tertiary') %>% osmdata_sf()
tertiary          <- tertiary$osm_lines[,c('osm_id', 'oneway', 'lanes', 'geometry')]
tertiary$type     <- 'tertiary'

Then bind them all into one object

roads             <- rbind(primary, secondary, motorway, trunk, tertiary) 

roads$osm_id      <- as.numeric(as.character(roads$osm_id))

rm(primary, secondary, motorway, trunk, tertiary)

Now that we have a SpatialLinesDataFrame of all the London roads, we delete the ones where the ‘lane’ attribute is not formed properly or contains an error.

roads$lanes       <- as.character(roads$lanes)
roads             <- roads[!grepl(';', roads$lanes),]
roads$lanes       <- as.numeric(roads$lanes)

The number of lanes for each road type is below.

table(roads$type, roads$lanes)
##            
##                1  1.5    2    3    4    5    6    8
##   motorway     2    0  148  543  314   57   15    0
##   primary    976    0 3178  830  205   48    3    0
##   secondary  284    0  791   43    5    1    0    0
##   tertiary   498    6 1248   91   14    1    0    0
##   trunk      266    0 2741 1773  564   82   25    2

Where this is missing, we fill in the blanks, using the mean values of that road type, rounded.

roads[roads$type == 'primary'     & is.na(roads$lanes),'lanes'] <- round(mean(roads[roads$type == 'primary'     & !is.na(roads$lanes),]$lanes),0)
roads[roads$type == 'secondary'   & is.na(roads$lanes),'lanes'] <- round(mean(roads[roads$type == 'secondary'   & !is.na(roads$lanes),]$lanes),0)
roads[roads$type == 'motorway'    & is.na(roads$lanes),'lanes'] <- round(mean(roads[roads$type == 'motorway'    & !is.na(roads$lanes),]$lanes),0)
roads[roads$type == 'trunk'       & is.na(roads$lanes),'lanes'] <- round(mean(roads[roads$type == 'trunk'       & !is.na(roads$lanes),]$lanes),0)
roads[roads$type == 'tertiary'    & is.na(roads$lanes),'lanes'] <- round(mean(roads[roads$type == 'tertiary'    & !is.na(roads$lanes),]$lanes),0)

Now, presuming that a lane is 3.15 metres wide, each road width is now calculated and added to the dataset.

roads$width             <- as.numeric(roads$lanes) * 3.15

OSM splits some roads into two, like Marylebone Road. This is a problem for calculating height to width ratios. So we are going to try and identify these.

roads$half_of_one <- NA

roads[roads$oneway == 'yes' & !is.na(roads$oneway) & roads$type == 'trunk' & !is.na(roads$type),'half_of_one'] <- as.character('Yes')

The road widths by road type are now as below

aggregate(width ~ type, data=roads, FUN=summary)
##        type width.Min. width.1st Qu. width.Median width.Mean width.3rd Qu.
## 1  motorway   3.150000      9.450000     9.450000  10.370064     12.600000
## 2   primary   3.150000      6.300000     6.300000   6.382108      6.300000
## 3 secondary   3.150000      6.300000     6.300000   6.175161      6.300000
## 4  tertiary   3.150000      6.300000     6.300000   6.209885      6.300000
## 5     trunk   3.150000      6.300000     9.450000   8.404815      9.450000
##   width.Max.
## 1  18.900000
## 2  18.900000
## 3  15.750000
## 4  15.750000
## 5  25.200000
ggplot(roads, aes(y = width, x = type, group=type, fill=type)) + geom_boxplot() + ggtitle('Road widths by road type')

The widest road in the dataset is here

m <- mapview(st_buffer(st_transform(roads[roads$width>25,][1,],27700),100), map.types = 'Esri.WorldImagery', alpha.regions=0.1)
mapshot(m, file = paste0(getwd(), "/map.png"), remove_controls = c("zoomControl", "layersControl", "homeButton","scaleBar"))

Pavement width is also added to the roads, depending on what type of road it is, as follows. Presumes 3 metres wide pavement

roads$pavement_width   <- NA

roads[roads$type == 'primary'   & is.na(roads$half_of_one),  'pavement_width'] <- 6
roads[roads$type == 'secondary' & is.na(roads$half_of_one),  'pavement_width'] <- 6
roads[roads$type == 'motorway'  & is.na(roads$half_of_one),  'pavement_width'] <- 0
roads[roads$type == 'trunk'     & is.na(roads$half_of_one),  'pavement_width'] <- 6
roads[roads$type == 'tertiary'  & is.na(roads$half_of_one),  'pavement_width'] <- 6

roads[roads$type == 'primary'   & !is.na(roads$half_of_one) & roads$half_of_one == 'Yes', 'pavement_width'] <- 3
roads[roads$type == 'secondary' & !is.na(roads$half_of_one) & roads$half_of_one == 'Yes', 'pavement_width'] <- 3
roads[roads$type == 'motorway'  & !is.na(roads$half_of_one) & roads$half_of_one == 'Yes', 'pavement_width'] <- 0
roads[roads$type == 'trunk'     & !is.na(roads$half_of_one) & roads$half_of_one == 'Yes', 'pavement_width'] <- 3
roads[roads$type == 'tertiary'  & !is.na(roads$half_of_one) & roads$half_of_one == 'Yes', 'pavement_width'] <- 3

roads$total_width <- roads$width + roads$pavement_width

Add half central reservation

roads[roads$half_of_one == 'Yes' & !is.na(roads$half_of_one),]$total_width <- roads[roads$half_of_one == 'Yes' & !is.na(roads$half_of_one),]$total_width + 2

With pavements added the roads width is..

aggregate(total_width ~ type, data=roads, FUN=summary)
##        type total_width.Min. total_width.1st Qu. total_width.Median
## 1  motorway          3.15000             9.45000            9.45000
## 2   primary          9.15000            12.30000           12.30000
## 3 secondary          9.15000            12.30000           12.30000
## 4  tertiary          9.15000            12.30000           12.30000
## 5     trunk          8.15000            11.30000           14.45000
##   total_width.Mean total_width.3rd Qu. total_width.Max.
## 1         10.37006            12.60000         18.90000
## 2         12.38211            12.30000         24.90000
## 3         12.17516            12.30000         21.75000
## 4         12.20988            12.30000         21.75000
## 5         13.64558            14.45000         30.20000
ggplot(roads, aes(y = total_width, x = type, group=type, fill=type)) + geom_boxplot() + ggtitle('Road widths by road type')

The map below shows roads currently in the dataset, coloured by type

ggplot(roads, aes(colour = type, fill=type)) + 
  geom_sf() +
  ggtitle('Downloaded OSM roads, by road type') +
  theme(axis.text = element_blank(),
        panel.background = element_blank(),
        axis.ticks = element_blank(),
        legend.position = 'bottom')

Remove a few circular roads that are a problem for buffers

roads_to_ignore         <- c(9393,11079,14595,15578)
roads                   <- roads[-roads_to_ignore,]
rm(roads_to_ignore)

Make the buffers around the roads

roads                   <- st_transform(roads, 27700)

roads$area              <- st_geometry(st_buffer(roads, dist = 15)) / st_geometry(st_buffer(roads, dist = 10))

For the roads like Marylebone Road, going to double and add 5 metres to the buffers.

roads[!is.na(roads$half_of_one),]$area              <- st_geometry(st_buffer(roads[!is.na(roads$half_of_one),], dist = 15*2+5)) /
                                                       st_geometry(st_buffer(roads[!is.na(roads$half_of_one),], dist = 10*2+5))

Transform the buffers to the same CRS as the raster we’re going to extract from.

roads$geometry          <- st_transform(roads$geometry,4326)
roads$area              <- st_transform(roads$area, 4326)

roads$geometry          <- st_transform(roads$geometry, crs(london_raster)@projargs)
roads$area              <- st_transform(roads$area, crs(london_raster)@projargs)

Check everything looks ok

plot(london_raster, xlim=c(3621000, 3622000), ylim = c(3204000,3205000))
plot(st_geometry(roads), xlim=c(3621000, 3622000), add=T)
plot(st_geometry(roads$area), xlim=c(3621000, 3622000), add=T)

Interactive map view of one feature

osm_id_to_examine <- 379356929

temp_raster <- extent(st_bbox(roads[roads$osm_id == osm_id_to_examine,])$xmin-40, st_bbox(roads[roads$osm_id == osm_id_to_examine,])$xmax+40, 
                      st_bbox(roads[roads$osm_id == osm_id_to_examine,])$ymin-40, st_bbox(roads[roads$osm_id == osm_id_to_examine,])$ymax+40)
temp_raster <- crop(london_raster, temp_raster)

mapview(temp_raster, alpha.regions = 0.4, map.types = 'OpenStreetMap.BlackAndWhite') %>% addFeatures(st_transform(roads[roads$osm_id == osm_id_to_examine,],4326))
rm(temp_raster, osm_id_to_examine)

Now extract the data we need from the raster (this takes circa 12 hours)

start_time <- Sys.time()

road_polygons       <- as(roads$area,'Spatial')
roads$area          <- NULL 

roads$weighted_mean <- NA
roads$cell_count    <- NA
roads$zero_cells    <- NA

print('about extracting data')
## [1] "about extracting data"
extracted <- extract(london_raster, road_polygons, weights=T, na.rm=F)

print('extracted data, using sapply to put into the roads file')
## [1] "extracted data, using sapply to put into the roads file"
roads$weighted_mean                           <- sapply(extracted, FUN = function(x)(sum(x[,1] * x[,2])))
roads$cell_count                              <- sapply(extracted, FUN = function(x)(length(x[,1])))
roads$zero_cells                              <- sapply(extracted, FUN = function(x)(sum(x[,1]==0)))
roads$max_height                              <- sapply(extracted, FUN = function(x)(max(x[,1], na.rm=T)))
## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf

## Warning in max(x[, 1], na.rm = T): no non-missing arguments to max;
## returning -Inf
roads$non_zero_means                          <- sapply(extracted, FUN = function(x)(sum(x[x[,1]>0,1] * (x[x[,1]>0,2] / sum(x[x[,1]>0,2])))))

roads[roads$max_height == '-Inf',]$max_height <- NA

print('done')
## [1] "done"
roads$geometry      <- st_transform(roads$geometry, 4326)

rm(london_raster)

end_time <- Sys.time()

print(end_time - start_time)
## Time difference of 12.98198 hours
rm(start_time, end_time)

Now need to get the bearing of each road from start point to end point

roads$bearing             <- line_bearing(roads)

hist(roads$bearing)

Where the road is ‘half of one’, double the width of the road

roads[roads$half_of_one == 'Yes' & !is.na(roads$half_of_one),]$total_width <- roads[roads$half_of_one == 'Yes' & !is.na(roads$half_of_one),]$total_width * 2

Add another column for height to width ratio

roads$height_width_ratio <- roads$weighted_mean / roads$total_width

Add another height widhth ratio column for when using the non-zero height from the raster

roads$height_width_ratio_excl_zeros <- roads$non_zero_means / roads$total_width

Now plot the non-zero height/width ratios.

ggplot(roads, aes(y = height_width_ratio, group=type, x=type, fill=type)) + geom_boxplot() + ggtitle('Height to width ratio by street type')
## Warning: Removed 7506 rows containing non-finite values (stat_boxplot).

Need to classify the roads as canyons and directions for modelling. If the height is above 10 metres they will be classified as a low canyon, above 20, a medium canyon, above 30 a high canyon + a specific directio.

roads$classification     <- NA

First the North-South canyon road type (type 1)

roads[roads$non_zero_means > 10 & roads$non_zero_means <= 20 & !is.na(roads$non_zero_means) & roads$bearing >= -22.5   & roads$bearing <= 22.5,]$classification    <- '1a'
roads[roads$non_zero_means > 10 & roads$non_zero_means <= 20 & !is.na(roads$non_zero_means) & roads$bearing >= 157.5   & roads$bearing <= 180,]$classification     <- '1a'
roads[roads$non_zero_means > 10 & roads$non_zero_means <= 20 & !is.na(roads$non_zero_means) & roads$bearing <= -157.5  & roads$bearing > -180,]$classification     <- '1a'


roads[roads$non_zero_means > 20 & roads$non_zero_means <= 30 & !is.na(roads$non_zero_means) & roads$bearing >= -22.5   & roads$bearing <= 22.5,]$classification  <- '1b'
roads[roads$non_zero_means > 20 & roads$non_zero_means <= 30 & !is.na(roads$non_zero_means) & roads$bearing >= 157.5   & roads$bearing <= 180,]$classification   <- '1b'
roads[roads$non_zero_means > 20 & roads$non_zero_means <= 30 & !is.na(roads$non_zero_means) & roads$bearing <= -157.5  & roads$bearing > -180,]$classification   <- '1b'

roads[roads$non_zero_means > 30 & !is.na(roads$non_zero_means) & roads$bearing >= -22.5   & roads$bearing <= 22.5,]$classification  <- '1c'
roads[roads$non_zero_means > 30 & !is.na(roads$non_zero_means) & roads$bearing >= 157.5   & roads$bearing <= 180,]$classification   <- '1c'
roads[roads$non_zero_means > 30 & !is.na(roads$non_zero_means) & roads$bearing <= -157.5  & roads$bearing > -180,]$classification   <- '1c'

Now the East-West canyon road type (type 2)

roads[roads$non_zero_means > 10 & roads$non_zero_means <= 20 & !is.na(roads$non_zero_means) & roads$bearing >= 67.5    & roads$bearing <= 112.5,]$classification <- '2a'
roads[roads$non_zero_means > 10 & roads$non_zero_means <= 20 & !is.na(roads$non_zero_means) & roads$bearing >= -112.5  & roads$bearing <= -67.5,]$classification <- '2a'

roads[roads$non_zero_means > 20 & roads$non_zero_means <= 30 & !is.na(roads$non_zero_means) & roads$bearing >= 67.5    & roads$bearing <= 112.5,]$classification <- '2b'
roads[roads$non_zero_means > 20 & roads$non_zero_means <= 30 & !is.na(roads$non_zero_means) & roads$bearing >= -112.5  & roads$bearing <= -67.5,]$classification <- '2b'

roads[roads$non_zero_means > 30 & !is.na(roads$non_zero_means) & roads$bearing >= 67.5    & roads$bearing <= 112.5,]$classification <- '2c'
roads[roads$non_zero_means > 30 & !is.na(roads$non_zero_means) & roads$bearing >= -112.5  & roads$bearing <= -67.5,]$classification <- '2c'

Now the South-East to North-West canyon road type (type 3)

roads[roads$non_zero_means > 10 & roads$non_zero_means <= 20 & !is.na(roads$non_zero_means) & roads$bearing >= 112.5    & roads$bearing <= 157.5,]$classification  <- '3a'
roads[roads$non_zero_means > 10 & roads$non_zero_means <= 20 & !is.na(roads$non_zero_means) & roads$bearing <= -22.5  & roads$bearing   >= -67.5,]$classification  <- '3a'

roads[roads$non_zero_means > 20 & roads$non_zero_means <= 30 & !is.na(roads$non_zero_means) & roads$bearing >= 112.5    & roads$bearing <= 157.5,]$classification  <- '3b'
roads[roads$non_zero_means > 20 & roads$non_zero_means <= 30 & !is.na(roads$non_zero_means) & roads$bearing <= -22.5  & roads$bearing   >= -67.5,]$classification  <- '3b'

roads[roads$non_zero_means > 30  & !is.na(roads$non_zero_means) & roads$bearing >= 112.5    & roads$bearing <= 157.5,]$classification  <- '3c'
roads[roads$non_zero_means > 30  & !is.na(roads$non_zero_means) & roads$bearing <= -22.5  & roads$bearing   >= -67.5,]$classification  <- '3c'

Now the South-West to North-East canyon road type (type 4)

roads[roads$non_zero_means > 10 & roads$non_zero_means <= 20 & !is.na(roads$non_zero_means) & roads$bearing >= 22.5    & roads$bearing  <= 67.5,]$classification   <- '4a'
roads[roads$non_zero_means > 10 & roads$non_zero_means <= 20 & !is.na(roads$non_zero_means) & roads$bearing <= -112.5  & roads$bearing >= -157.5,]$classification  <- '4a'

roads[roads$non_zero_means > 20 & roads$non_zero_means <= 30 & !is.na(roads$non_zero_means) & roads$bearing >= 22.5    & roads$bearing  <= 67.5,]$classification   <- '4b'
roads[roads$non_zero_means > 20 & roads$non_zero_means <= 30 & !is.na(roads$non_zero_means) & roads$bearing <= -112.5  & roads$bearing >= -157.5,]$classification  <- '4b'

roads[roads$non_zero_means > 30 & !is.na(roads$non_zero_means) & roads$bearing >= 22.5    & roads$bearing  <= 67.5,]$classification   <- '4c'
roads[roads$non_zero_means > 30 & !is.na(roads$non_zero_means) & roads$bearing <= -112.5  & roads$bearing >= -157.5,]$classification  <- '4c'

Now non-street-canyons that are open roads are classified as type 5. There are 10991 of these.

roads[roads$non_zero_means <= 1 & !is.na(roads$non_zero_means) ,]$classification   <- 5 #open

Now non-street-canyons that are typical roads are classified as type 6. There are 18915 of these.

roads[roads$non_zero_means > 1 & roads$non_zero_means <= 10 & !is.na(roads$non_zero_means) ,]$classification    <- 6 #typical

Haven’t been working on them, but think it’s time time to add the residential roads back in and harmonise them with the main roads data.

residential           <- opq(bbox = c(min_x, min_y, max_x, max_y)) %>% add_osm_feature(key = 'highway', value='residential') %>% osmdata_sf()
residential           <- residential$osm_lines[,c('osm_id', 'oneway', 'lanes', 'geometry')]
residential$type      <- 'residential'

residential$osm_id      <- as.numeric(as.character(residential$osm_id))

residential$lanes       <- as.character(residential$lanes)
residential             <- residential[!grepl(';', residential$lanes),]
residential$lanes       <- as.numeric(residential$lanes)

residential[is.na(residential$lanes),'lanes'] <- 2

residential$width                           <- residential$lanes * 3.15
residential$half_of_one                     <- as.character(NA)
residential$pavement_width                  <- as.numeric(6)
residential$total_width                     <- as.numeric(residential$width + residential$pavement_width)
residential$weighted_mean                   <- as.numeric(NA)
residential$cell_count                      <- as.integer(NA)
residential$zero_cells                      <- as.integer(NA)
residential$bearing                         <- as.numeric(NA)
residential$height_width_ratio              <- as.numeric(NA)
residential$max_height                      <- as.numeric(NA)
residential$non_zero_means                  <- as.numeric(NA)
residential$height_width_ratio_excl_zeros   <- as.numeric(NA)
residential$classification                  <- as.numeric(6)

col_order <- names(roads)

residential <- residential[,col_order]

roads <- rbind(roads, residential)

rm(residential)

Now get the median height and width for each road type

road_characteristics <- data.frame(aggregate(data = roads, cbind(total_width, non_zero_means) ~ classification, FUN=mean))

kable(road_characteristics)
classification total_width non_zero_means
1a 15.31079 13.575592
1b 14.91070 24.307168
1c 14.60340 39.939244
2a 16.06054 13.643353
2b 16.04821 23.923973
2c 15.84870 42.252502
3a 16.10932 13.456773
3b 15.92794 24.180568
3c 17.21582 39.528609
4a 15.54837 13.730182
4b 15.50635 23.743554
4c 17.76146 41.896967
5 13.56643 0.000000
6 14.29772 7.310619 
st_write(roads, 'final_roads_london.geojson', delete_dsn = T)
## Deleting source `final_roads_london.geojson' failed
## Writing layer `final_roads_london' to data source `final_roads_london.geojson' using driver `GeoJSON'
## features:       143778
## fields:         17
## geometry type:  Line String